home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 March - Disc 1 / Macworld (1999-03) (Disk 1).dmg / Shareware World / Utilities / Text Processing / Alpha / Tcl / Modes / javaMode.tcl < prev    next >
Encoding:
Text File  |  1998-11-14  |  9.4 KB  |  295 lines  |  [TEXT/ALFA]
  1. # (install)
  2.  
  3. alpha::mode Java 1.09 javaMenu {*.java *.j} {
  4.     javaMenu electricBraces electricSemicolon electricReturn
  5. } {
  6.     addMenu javaMenu "•140" Java
  7. }
  8.  
  9. array set javacompilerAppSignatures {
  10.     Suncompiler Javc
  11. }
  12. array set javacompilerAppScripts {
  13.     Suncompiler {
  14.     {sendOpenEvent -n $quotedSig $filename}
  15.     }
  16. }
  17.  
  18. # required for use of C++::correctIndentation
  19. newPref f useFasterButWorseIndentation 0 Java
  20. newPref v indentComments "code 0" Java "" indentationTypes varitem
  21. newPref v indentC++Comments "code 0" Java "" indentationTypes varitem
  22.  
  23. newPref    f elecColon {1} Java
  24. newPref    v leftFillColumn {3} Java
  25. newPref    v prefixString {//} Java 
  26. newPref    f wordWrap {0} Java
  27. newPref    v funcExpr {^[^ \t\(#\r/@].*\(.*\)$} Java
  28. newPref    v parseExpr {\b([_:\w]+)\s*\(} Java
  29. newPref v wordBreak {[\w_]+} Java
  30. newPref v wordBreakPreface {[^_\w]} Java
  31. newPref    f autoMark    0 Java
  32. newPref    v stringColor    green Java
  33. newPref    v commentColor    red     Java
  34. newPref    v keywordColor    blue Java
  35. newPref f includeMenu 1 Java
  36. newPref variable showJavacompilerLog 1 Java "" \
  37.   [list "Never" "Only after error" "Always"] index
  38.  
  39. regModeKeywords     -e {//} -b {/*} {*/} -c $JavamodeVars(commentColor) -k    $JavamodeVars(keywordColor)  -s    $JavamodeVars(stringColor) Java    {
  40.     abstract boolean break byte byvalue case catch char class const 
  41.     continue default do double else extends false final finally float for 
  42.     goto if implements import instanceof int interface long native new 
  43.     null package private protected public return short static super switch 
  44.     synchronized this throw throws transient true try void while future 
  45.     generic inner outer operator rest var volatile
  46. }
  47.  
  48. proc javaMenu {} {}
  49.  
  50. ## 
  51.  # -------------------------------------------------------------------------
  52.  # 
  53.  # "menu::buildjavaMenu" --
  54.  # 
  55.  #  Use a build proc so we can add things on the fly.
  56.  # -------------------------------------------------------------------------
  57.  ##
  58. proc Java::buildMenu {} {
  59.     global javaMenu
  60.     set ma {
  61.     "/S<U<OswitchToCompiler"
  62.     "(-"
  63.     "/K<U<OcompileFile"
  64.     "(-"
  65.     "/V<U<OviewApplet"
  66.     "//<BnewJavadocComment"
  67.     }
  68.     return [list build $ma Java::MenuProc "" $javaMenu]
  69. }
  70. menu::buildProc javaMenu Java::buildMenu
  71.  
  72. set Java::commentCharacters(Paragraph) [list "/**" " */" " * "]
  73.  
  74. # If this package exists, add the headers menu
  75. if [alpha::package exists searchPaths] {
  76.     menu::buildProc javaSearchPath {mode::rebuildSearchPathMenu javaSearchPath}
  77.     menu::insert javaMenu submenu end javaSearchPath
  78. }
  79.  
  80. menu::buildSome javaMenu
  81.  
  82. proc Java::MenuProc {menu item} {
  83.     eval Java::$item
  84. }
  85.  
  86. proc Java::correctIndentation {args} {
  87.     uplevel 1 C++::correctIndentation $args
  88. }
  89. proc Java::indentLine {args} {
  90.     uplevel 1 C++::indentLine $args
  91. }
  92.  
  93. proc Java::newJavadocComment {} {
  94.     elec::Insertion "/**\r * •comment body•\r */\r••"
  95. }
  96.  
  97. # Launches Java Compiler
  98. proc Java::switchToCompiler {} {
  99.     global javacompilerSig
  100.     app::launchAnyOfThese Javc javacompilerSig "Please locate the Java compiler:"
  101.     switchTo '$javacompilerSig'
  102. }
  103.  
  104. # Sends the window to the compiler.
  105. proc Java::compileFile {} {
  106.     global showJavacompilerLog
  107.     set path [stripNameCount [win::Current]]
  108.  
  109.     if {[winDirty]} {
  110.     case [askyesno -c "Save '[file tail $path]'?"] in {
  111.         "yes" {
  112.         save
  113.         # Get path again, in case it was Untitled before.
  114.         set path [stripNameCount [win::Current]]
  115.         }
  116.         "no" {
  117.         if {![file exists $path]} {
  118.             alertnote "Can't send window to compiler."
  119.             return
  120.         }
  121.         }
  122.         "cancel" {return}
  123.     }
  124.     }
  125.     app::runScript javacompiler "Java compiler" \
  126.       $path 0 $showJavacompilerLog
  127. }
  128.  
  129. # Opens a HTML file corresponding to a java file in the Applet Viewer.
  130. # If there is a file some_applet.html in the same folder as some_applet.java
  131. # it is sent. Otherwise the user is asked to select a HTML file.
  132. # This file is remembered throughout this session with Alpha.
  133. proc Java::viewApplet {} {
  134.     global javaAppletFile javaviewerSig
  135.     set name [stripNameCount [win::Current]]
  136.     set dir [file dirname $name]
  137.     set root [file rootname [file tail $name]]
  138.     set path [file join $dir $root.html]
  139.     if {[info exists javaAppletFile($name)] && [file exists $javaAppletFile($name)]} {
  140.     set path $javaAppletFile($name)
  141.     } elseif {![file exists $path]} {
  142.     set path [getfile "Please locate HTML file for applet."]
  143.     set javaAppletFile($name) $path
  144.     }
  145.     app::launchAnyOfThese [list AppV WARZ] javaviewerSig "Please locate the Applet viewer:"
  146.     sendOpenEvent noReply '$javaviewerSig' $path
  147.     switchTo '$javaviewerSig'
  148. }
  149.  
  150. proc Java::MarkFile {} {
  151.     Java::MarkFile2 1
  152. }
  153.  
  154. proc Java::parseFuncs {} {
  155.     Java::MarkFile2 0
  156. }
  157.  
  158.  
  159. # My version of    Java::MarkFile. First revision, April 1996.
  160. # Jim Menard, jimm@io.com
  161. # Improved by Vince: both start and end position of embedded classes are
  162. # stored, so if we order methods/sub-classes randomly, we still mark 
  163. # things properly.
  164. proc Java::MarkFile2 {marking} {
  165.     # Sorry, but globals are a lot easier than using "upvar" in subroutines
  166.     global markArray
  167.     global classInfo
  168.     
  169.     catch {unset markArray}
  170.     set classInfo ""
  171.     
  172.     # Look for class definitions first
  173.     set markExpr "^\[ \t\]*(\[A-Za-z_\]\[A-Za-z0-9_\]*\[ \t\]+)*class\[ \t\]+\[A-Za-z_\]\[A-Za-z0-9_\]*\[ \t\r\](\[A-Za-z_\]\[A-Za-z0-9_.\]*\[ \t\]+)*\{"
  174.     set wordExpr "class\[ \t\]+(\[A-Za-z_\]\[A-Za-z0-9_\]*)"
  175.     set commands {
  176.     set markArray([concat $word "class"]) $markPos
  177.     # Remember mark    position and name separately so    we can call
  178.     # Java::getClassFromPos() later.
  179.     lappend    classInfo [list $word $markPos $endPos]
  180.     }
  181.     Java::searchAndDestroy $markExpr $wordExpr $commands 0
  182.     
  183.     # The following regular expression is overly restrictive. After the open
  184.     # paren, I disallow semicolons. That avoids finding lines like
  185.     # throw new FooException(arg);
  186.     # which is good, but unfortunately also avoids finding lines like
  187.     # public int foo(arg) // comment with semi;
  188.     #
  189.     # It doesn't find constructors without a "public", "private", or other phrase
  190.     # before the method name since it requires at least one word before the
  191.     # method name. They are special-cased below. I did that so function calls,
  192.     # "if" statements, and the like wouldn't be found.
  193.     set markExpr "^\[ \t\]*(\[A-Za-z_\]\[A-Za-z0-9_\]*(\\\[\\])*\[ \t\]+)+\[A-Za-z_\]\[A-Za-z0-9_\]*\[ \t\r\]*\\(\[^;\]+$"
  194.     set wordExpr "(\[A-Za-z_\]\[A-Za-z0-9_\]*)\[ \t\]*\\("
  195.     set commands {
  196.     if {$className == $word} {
  197.         set markArray([concat $className "constructor"]) $markPos
  198.     } else {
  199.         set markArray(${className}::$word) $markPos
  200.     }
  201.     }
  202.     Java::searchAndDestroy $markExpr $wordExpr $commands 1
  203.     
  204.     # One more time; let's go back for constructors    with no    modifiers.
  205.     set markExpr "^\[ \t\]*\[A-Za-z\]\[A-Za-z0-9_\]*\[ \t\r\]*\\(\[^;\]+$"
  206.     set wordExpr "(\[A-Za-z\]\[A-Za-z0-9_\]*)\[ \t\]*\\("
  207.     set commands {
  208.     if {$className == $word} {
  209.         set markArray([concat $className "constructor"]) [lineStart [expr $start - 1]]
  210.     }
  211.     }
  212.     Java::searchAndDestroy $markExpr $wordExpr $commands 1
  213.     
  214.     if {[info exists markArray]} {
  215.     foreach    f [lsort -ignore [array    names markArray]] {
  216.         set next [nextLineStart $markArray($f)]
  217.         
  218.         if {[regexp {.*(::if)$} $f] == 0} {
  219.         if {[string length $f] > 35} { 
  220.             set ff "[string range $f 0 31]..." 
  221.         } else {
  222.             set ff $f
  223.         }
  224.         if {$marking} {
  225.             setNamedMark "$ff" "$markArray($f)" $next $next
  226.         } else {
  227.             lappend parse $ff $next
  228.         }
  229.         }
  230.     }
  231.     }
  232.     if {!$marking} {return $parse}
  233. }
  234.  
  235. # Start    at top of file and find    text that matches markExpr. Clean it up    and
  236. # use wordExpr to find the word    we want. Execute commands.
  237. proc Java::searchAndDestroy {markExpr wordExpr commands needClassName} {
  238.     global markArray
  239.     global classInfo
  240.     if {!$needClassName} {
  241.     set getEnd 0
  242.     }
  243.     
  244.     set pos [minPos]
  245.     while {![catch {search -s -f 1 -r 1 -m 0 -i 0 -- "$markExpr" $pos} res]} {
  246.     set start [lindex $res 0]
  247.     set end    [pos::math [lindex $res 1] + 1]
  248.     if {[pos::compare $end > [maxPos]]} {
  249.         set end [maxPos]
  250.     }
  251.     set thistext [getText $start $end]
  252.     if {$needClassName} {
  253.         set className [Java::getClassFromPos $start $classInfo]
  254.     }
  255.     # regexp doesn't like carriage returns or tabs
  256.     regsub -all "\[\n\r\t\]" $thistext " " thistext
  257.     # If the open paren was    the last character on the line,
  258.     # the selected text included the last carriage return as well.
  259.     # Trim this off    now that it is changed into a space.
  260.     set thistext [string trimright $thistext]
  261.     if {[regexp $wordExpr $thistext    dummy word]} {
  262.         set markPos [lineStart [pos::math $start - 1]]
  263.         if {[info exists getEnd]} {
  264.         if {$getEnd} {
  265.             set endPos [lindex [search -s -f 1 -m 0 -i 0 -- "\{" $markPos] 1]
  266.             set endPos [matchIt "\{" $endPos]
  267.         } else {
  268.             # little efficiency thing: the first class we find, we know
  269.             # extends to the end of the file, so we don't bother doing
  270.             # its 'matchIt' because it is very time-consuming.
  271.             set endPos [maxPos]
  272.             set getEnd 1
  273.         }
  274.         }
  275.         eval $commands
  276.     }
  277.     set pos    $end
  278.     }
  279. }
  280.  
  281. # Given    a file position, find the class    definition in which it resides.
  282. # There's got to be an easier way than passing two separate lists. 
  283. # I tried fooling
  284. # around with markArray(), but don't know Tcl well enough to use it instead.
  285. proc Java::getClassFromPos {pos classInfo} {
  286.     set nClasses [llength $classInfo]
  287.     for {set i [expr {$nClasses - 1}]} {$i >= 0} {incr i -1} {
  288.     set range [lindex $classInfo $i]
  289.     if {[pos::compare [lindex $range 1] <= $pos] && [pos::compare [lindex $range 2] >= $pos]} {
  290.         return [lindex $range 0]
  291.     }
  292.     }
  293.     return ""
  294. }
  295.